import sun.security.util.AlgorithmDecomposer;

public class Test3 {
    public static void main(String[] args) {
        Alg<String> alg1 = new Alg<String>();
        alg1.setT("Matty");
        Test3.fun(alg1);
        Alg<Integer> alg2 = new Alg<Integer>();
        alg2.setT(20);
        Test3.fun(alg2);
    }

//    ?即通配符，可以传递任意的类类型
    public static void fun (Alg<?> alg) {
        System.out.println(alg.getT());
    }


    public static void main1(String[] args) {
        /**
         * 这个类纯粹为了使用他的查找数组最大值方法
         */
        Alg<Integer> alg = new Alg<>();

//        int[] arr = new int[]{1,4,5,6,2,6,4,7,342};
        //这样子程序会报错，因为findMaxVal要求的是T类型，T表示类类型，int不是一个类

        Integer[] arr = new Integer[] {1,2,3,4,5,4,4,3,2,1};
//        System.out.println(alg.findMaxVal(arr));

        System.out.println(Alg2.findMaxVal(arr));

    }

}

//  Alg2是普通类
//  findMaxVal是泛型方法
class Alg2 {
    public static<T extends Comparable<T>> T findMaxVal (T[] arr) {
        T tmp = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].compareTo(tmp) > 0) {
                tmp = arr[i];
            }
        }
        return tmp;
    }
}

/**
 * 尝试将findMaxVal写成静态方法，结果报错，因为静态方法不应该依赖对象，但是该方法以来了对象T
 */
//class Alg2<T extends Comparable<T>> {
//    public static T findMaxVal(T[] arr) {
//        T tmp = arr[0];
//        for (int i = 0; i < arr.length; i++) {
//            if (tmp.compareTo(arr[i]) < 0) {
//                tmp = arr[i];
//            }
//        }
//        return tmp;
//    }
//}

//    findMaxVal方法依赖对象
//    Alg是一个泛型类
class Alg<T extends Comparable<T>> {
    T t;

    public T findMaxVal(T[] arr) {
        T tmp = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (tmp.compareTo(arr[i]) < 0) {
                tmp = arr[i];
            }
        }
        return tmp;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}